{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LgJeQHs1uZrV"
      },
      "source": [
        "# Checkpoint modifications\n",
        "\n",
        "Checkpoint modifications can be made to include more outputs or change certain aspects of the simulations (e.g., changing filters).\n",
        "\n",
        "Here, we demonstrate how to add an output for surface pressure and how to fix (make constant) the global mean log surface pressure. We found that the global mean surface pressure tends to drift in long integrations when using NeuralGCM, leading to less stable simulations. Fixing the global mean surface pressure increases stability in long integrations. The current reason for the drift in global mean surface pressure in long integrations is likely due to our dynamical core (and not the machine learning component), as we verified that using the dynamical core with orography also results in a drift in the global mean log surface pressure.\n",
        "\n",
        "\n",
        "Steps:\n",
        "1. Change the checkpoint to include surface pressure as an output variable and enforce a constant global mean log surface pressure.\n",
        "2. Run the model and verify that the global mean log surface pressure is kept constant.\n",
        "3. Run the model without fixing the global mean log surface pressure.\n",
        "\n",
        "There are other scenarios where you might want to modify a checkpoint. For example, in this [issue](https://github.com/neuralgcm/neuralgcm/issues/12) we discuss to add a precipitation minus evaporation diagnostic.\n",
        "\n",
        "\n",
        "```{warning}\n",
        "These modified models have not been extensively tested by the NeuralGCM team.\n",
        "```\n",
        "\n",
        "```{tip}\n",
        "You can run this notebook yourself in [Google Colab](https://colab.research.google.com/github/neuralgcm/neuralgcm/blob/main/docs/checkpoint_modifications.ipynb). We recommend using a GPU or TPU runtime due to high memory and compute requirements.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hwjBVRPIR1ot"
      },
      "outputs": [],
      "source": [
        "# if necessary, install NeuralGCM and dependencies\n",
        "! pip install -q -U neuralgcm gcsfs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "do7_irWozluZ"
      },
      "outputs": [],
      "source": [
        "import gcsfs\n",
        "import jax\n",
        "import numpy as np\n",
        "import pickle\n",
        "import xarray\n",
        "\n",
        "from dinosaur import horizontal_interpolation\n",
        "from dinosaur import spherical_harmonic\n",
        "from dinosaur import xarray_utils\n",
        "import neuralgcm\n",
        "\n",
        "gcs = gcsfs.GCSFileSystem(token='anon')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KvdgI8IafPtO"
      },
      "source": [
        "## Change checkpoint to fix the global mean of log surface pressure\n",
        "\n",
        "```{tip}\n",
        "Only `v1` NeuralGCM models (from the original Nature paper) need this fix: the `v1_precip` models already have it applied.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ETOS8Y7Rk-fQ"
      },
      "outputs": [],
      "source": [
        "model_name = 'v1/deterministic_2_8_deg.pkl'  # @param ['v1/deterministic_0_7_deg.pkl', 'v1/deterministic_1_4_deg.pkl', 'v1/deterministic_2_8_deg.pkl', 'v1/stochastic_1_4_deg.pkl'] {type: \"string\"}\n",
        "\n",
        "with gcs.open(f'gs://neuralgcm/models/{model_name}', 'rb') as f:\n",
        "  ckpt = pickle.load(f)\n",
        "\n",
        "new_inputs_to_units_mapping = {\n",
        "    'u': 'meter / second',\n",
        "    'v': 'meter / second',\n",
        "    't': 'kelvin',\n",
        "    'z': 'm**2 s**-2',\n",
        "    'sim_time': 'dimensionless',\n",
        "    'tracers': {\n",
        "        'specific_humidity': 'dimensionless',\n",
        "        'specific_cloud_liquid_water_content': 'dimensionless',\n",
        "        'specific_cloud_ice_water_content': 'dimensionless',\n",
        "    },\n",
        "    'diagnostics': {\n",
        "        'surface_pressure': 'kg / (meter s**2)',\n",
        "    },\n",
        "}\n",
        "\n",
        "new_model_config_str = '\\n'.join([\n",
        "    ckpt['model_config_str'],\n",
        "    (\n",
        "        'DimensionalLearnedPrimitiveToWeatherbenchDecoder.inputs_to_units_mapping'\n",
        "        f' = {new_inputs_to_units_mapping}'\n",
        "    ),\n",
        "    (\n",
        "        'DimensionalLearnedPrimitiveToWeatherbenchDecoder.diagnostics_module ='\n",
        "        ' @NodalModelDiagnosticsDecoder'\n",
        "    ),\n",
        "    # Adding a diagnostic of surface pressure. If there are other diagnostics modules\n",
        "    # (e.g., PrecipitationMinusEvaporationDiagnostics) they will be removed.\n",
        "    (\n",
        "        'StochasticPhysicsParameterizationStep.diagnostics_module ='\n",
        "        ' @SurfacePressureDiagnostics'\n",
        "    ),\n",
        "    # Adding FixGlobalMeanFilter which fixes global mean log surface pressure.\n",
        "    (\n",
        "        'dycore/SequentialStepFilter.filter_modules ='\n",
        "        ' (@dycore/ExponentialFilter,@stability/ExponentialFilter,@surface_pressure/FixGlobalMeanFilter)'\n",
        "    ),\n",
        "])\n",
        "ckpt['model_config_str'] = new_model_config_str\n",
        "model = neuralgcm.PressureLevelModel.from_checkpoint(ckpt)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zToO25Vthle4"
      },
      "source": [
        "### Run model and verify that global mean log surface pressure is kept constant\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZIl1L-YLzuFg"
      },
      "outputs": [],
      "source": [
        "era5_path = 'gs://gcp-public-data-arco-era5/ar/full_37-1h-0p25deg-chunk-1.zarr-v3'\n",
        "full_era5 = xarray.open_zarr(\n",
        "    era5_path, chunks=None, storage_options=dict(token='anon')\n",
        ")\n",
        "\n",
        "demo_start_time = '2020-02-14'\n",
        "demo_end_time = '2020-02-16'\n",
        "data_inner_steps = 24  # process every 24th hour\n",
        "\n",
        "sliced_era5 = (\n",
        "    full_era5\n",
        "    [model.input_variables + model.forcing_variables]\n",
        "    .pipe(\n",
        "        xarray_utils.selective_temporal_shift,\n",
        "        variables=model.forcing_variables,\n",
        "        time_shift='24 hours',\n",
        "    )\n",
        "    .sel(time=slice(demo_start_time, demo_end_time, data_inner_steps))\n",
        "    .compute()\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FLhgQg5oz0I_"
      },
      "outputs": [],
      "source": [
        "era5_grid = spherical_harmonic.Grid(\n",
        "    latitude_nodes=full_era5.sizes['latitude'],\n",
        "    longitude_nodes=full_era5.sizes['longitude'],\n",
        "    latitude_spacing=xarray_utils.infer_latitude_spacing(full_era5.latitude),\n",
        "    longitude_offset=xarray_utils.infer_longitude_offset(full_era5.longitude),\n",
        ")\n",
        "regridder = horizontal_interpolation.ConservativeRegridder(\n",
        "    era5_grid, model.data_coords.horizontal, skipna=True\n",
        ")\n",
        "eval_era5 = xarray_utils.regrid(sliced_era5, regridder)\n",
        "eval_era5 = xarray_utils.fill_nan_with_nearest(eval_era5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "91AThK2Pz18l"
      },
      "outputs": [],
      "source": [
        "inner_steps = 1  # save model outputs once every 24 hours\n",
        "outer_steps = 30 * 1 // inner_steps  # total of 30 days\n",
        "timedelta = np.timedelta64(24, 'h') * inner_steps\n",
        "times = (np.arange(outer_steps) * inner_steps)  # time axis in hours\n",
        "\n",
        "# initialize model state\n",
        "inputs = model.inputs_from_xarray(eval_era5.isel(time=0))\n",
        "input_forcings = model.forcings_from_xarray(eval_era5.isel(time=0))\n",
        "rng_key = jax.random.key(42)  # optional for deterministic models\n",
        "initial_state = model.encode(inputs, input_forcings, rng_key)\n",
        "\n",
        "# use persistence for forcing variables (SST and sea ice cover)\n",
        "all_forcings = model.forcings_from_xarray(eval_era5.head(time=1))\n",
        "\n",
        "# make forecast\n",
        "final_state, predictions = model.unroll(\n",
        "    initial_state,\n",
        "    all_forcings,\n",
        "    steps=outer_steps,\n",
        "    timedelta=timedelta,\n",
        "    start_with_input=True,\n",
        ")\n",
        "predictions_ds_fix_lsp = model.data_to_xarray(predictions, times=times)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "28m6wEmqcAjR",
        "outputId": "590ae6d0-a53e-48f2-869a-a040410ed12f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Array([40.756054, 40.75604 , 40.75605 , 40.756035, 40.75604 , 40.756042,\n",
              "       40.756042, 40.756042, 40.756035, 40.75603 , 40.756042, 40.75604 ,\n",
              "       40.756042, 40.756035, 40.75604 , 40.756054, 40.75604 , 40.75605 ,\n",
              "       40.756042, 40.756046, 40.756042, 40.756042, 40.75604 , 40.75605 ,\n",
              "       40.75605 , 40.756046, 40.75604 , 40.756042, 40.756042, 40.756054],      dtype=float32)"
            ]
          },
          "execution_count": 65,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# to spherical harmonic representation (the 0,0 component is the global mean):\n",
        "log_sp_spherical_harmonics_fix_lsp = model.data_coords.horizontal.to_modal(predictions_ds_fix_lsp.surface_pressure.pipe(np.log))\n",
        "log_sp_spherical_harmonics_fix_lsp[:,0,0]  # Should be almost constant"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lcUY7D3YfGbL"
      },
      "source": [
        "### Run model without fixing the global mean log surface pressure\n",
        "\n",
        "Example: without fixing global mean log surface pressure (still adding surface\n",
        "pressure as an output variable)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m863UvyweLDR"
      },
      "outputs": [],
      "source": [
        "model_name = 'neural_gcm_dynamic_forcing_deterministic_2_8_deg.pkl'  # @param ['neural_gcm_dynamic_forcing_deterministic_0_7_deg.pkl', 'neural_gcm_dynamic_forcing_deterministic_1_4_deg.pkl', 'neural_gcm_dynamic_forcing_deterministic_2_8_deg.pkl', 'neural_gcm_dynamic_forcing_stochastic_1_4_deg.pkl'] {type: \"string\"}\n",
        "\n",
        "with gcs.open(f'gs://gresearch/neuralgcm/04_30_2024/{model_name}', 'rb') as f:\n",
        "  ckpt2 = pickle.load(f)\n",
        "\n",
        "\n",
        "new_inputs_to_units_mapping = {\n",
        "    'u': 'meter / second',\n",
        "    'v': 'meter / second',\n",
        "    't': 'kelvin',\n",
        "    'z': 'm**2 s**-2',\n",
        "    'sim_time': 'dimensionless',\n",
        "    'tracers': {\n",
        "        'specific_humidity': 'dimensionless',\n",
        "        'specific_cloud_liquid_water_content': 'dimensionless',\n",
        "        'specific_cloud_ice_water_content': 'dimensionless',\n",
        "    },\n",
        "    'diagnostics': {'surface_pressure': 'kg / (meter s**2)'},\n",
        "}\n",
        "\n",
        "new_model_config_str = '\\n'.join([\n",
        "    ckpt2['model_config_str'],\n",
        "    (\n",
        "        'DimensionalLearnedPrimitiveToWeatherbenchDecoder.inputs_to_units_mapping'\n",
        "        f' = {new_inputs_to_units_mapping}'\n",
        "    ),\n",
        "    (\n",
        "        'DimensionalLearnedPrimitiveToWeatherbenchDecoder.diagnostics_module ='\n",
        "        ' @NodalModelDiagnosticsDecoder'\n",
        "    ),\n",
        "    (\n",
        "        'StochasticPhysicsParameterizationStep.diagnostics_module ='\n",
        "        ' @SurfacePressureDiagnostics'\n",
        "    ),\n",
        "])\n",
        "ckpt2['model_config_str'] = new_model_config_str\n",
        "model = neuralgcm.PressureLevelModel.from_checkpoint(ckpt2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f_uHe20vdhsJ"
      },
      "outputs": [],
      "source": [
        "inner_steps = 1  # save model outputs once every 24 hours\n",
        "outer_steps = 30 * 1 // inner_steps  # total of 30 days\n",
        "timedelta = np.timedelta64(24, 'h') * inner_steps\n",
        "times = (np.arange(outer_steps) * inner_steps)  # time axis in hours\n",
        "\n",
        "# initialize model state\n",
        "inputs = model.inputs_from_xarray(eval_era5.isel(time=0))\n",
        "input_forcings = model.forcings_from_xarray(eval_era5.isel(time=0))\n",
        "rng_key = jax.random.key(42)  # optional for deterministic models\n",
        "initial_state = model.encode(inputs, input_forcings, rng_key)\n",
        "\n",
        "# use persistence for forcing variables (SST and sea ice cover)\n",
        "all_forcings = model.forcings_from_xarray(eval_era5.head(time=1))\n",
        "\n",
        "# make forecast\n",
        "final_state, predictions = model.unroll(\n",
        "    initial_state,\n",
        "    all_forcings,\n",
        "    steps=outer_steps,\n",
        "    timedelta=timedelta,\n",
        "    start_with_input=True,\n",
        ")\n",
        "predictions_ds = model.data_to_xarray(predictions, times=times)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ban5KYuFeyxP",
        "outputId": "487a3bbd-687a-4654-df2a-90939c226dfb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Array([40.756054, 40.756104, 40.75608 , 40.75609 , 40.75613 , 40.75616 ,\n",
              "       40.75618 , 40.75609 , 40.75605 , 40.75599 , 40.755817, 40.755783,\n",
              "       40.755848, 40.75599 , 40.75605 , 40.755997, 40.75583 , 40.75577 ,\n",
              "       40.75577 , 40.75577 , 40.755825, 40.755867, 40.755928, 40.75601 ,\n",
              "       40.756073, 40.756096, 40.75613 , 40.75609 , 40.756104, 40.75614 ],      dtype=float32)"
            ]
          },
          "execution_count": 68,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#to spherical harmonic representation (the 0,0 component is the global mean):\n",
        "log_sp_spherical_harmonics = model.data_coords.horizontal.to_modal(predictions_ds.surface_pressure.pipe(np.log))\n",
        "log_sp_spherical_harmonics[:,0,0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZG-fQW9fh9Xd"
      },
      "source": [
        "### Compare global mean log surface pressure\n",
        "\n",
        "Global mean log surface pressure now stays mostly fixed in a one-month long integration. The small changes are likely numerical errors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "id": "2uB4X0zQgj53",
        "outputId": "d93b16ec-5da8-4a46-84a3-f5e54df4179e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 640x480 with 1 Axes\u003e"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.plot(log_sp_spherical_harmonics_fix_lsp[:,0,0], label='Fixed global mean')\n",
        "plt.plot(log_sp_spherical_harmonics[:,0,0], label='No Fix')\n",
        "plt.legend()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "last_runtime": {
        "build_target": "//research/simulation/whirl/cfd/notebooks:notebook",
        "kind": "private"
      },
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
